/*
 * To change ApplicationMBean template, choose Tools | Templates
 * and open the template in the editor.
 */
package com.brain.core.view.mbean;

import com.brain.core.common.UtilCore;
import com.brain.core.configuracion.WebServletContextListener;
import com.brain.core.dto.ArchivoDto;
import com.brain.core.exception.DAOException;
import com.brain.core.manager.ArchivoManager;
import com.brain.core.manager.RecursosManager;
import java.io.*;
import java.math.BigDecimal;
import java.util.List;

import javax.annotation.Resource;
import org.apache.log4j.Logger;
import org.primefaces.event.FileUploadEvent;
import org.primefaces.model.StreamedContent;
import org.primefaces.model.UploadedFile;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Controller;

/**
 *
 * @author Indra
 */
@Controller("archivoMBean")
@Scope("session")
public class ArchivoMBean extends GenericMBean implements Serializable {

    private static Logger logger = Logger.getLogger(ArchivoMBean.class);
    private List<ArchivoDto> listaArchivos;
    private ArchivoDto archivoDto;
    @Resource
    private ArchivoManager manager;
    @Autowired
    private ApplicationMBean applicationMBean;
    @Autowired
    private SessionMBean sessionMBean;
    @Resource
    private RecursosManager recursosManager;
    
    private StreamedContent file; 
    
    public void cargarArchivos(Long entidad, Long registro) {
        try {
            this.listaArchivos = this.manager.obtenerArchivosRegistro(entidad, registro);
        } catch (DAOException ex) {
            logger.error(ex);
        }
    }
    
    public void cargarArchivos() {
        SessionMBean sessionMBean = (SessionMBean) WebServletContextListener.getApplicationContext().getBean("sessionMBean");
        try {
            this.listaArchivos = this.manager.obtenerArchivosRegistro(sessionMBean.getEntidad(), sessionMBean.getRegistro());
        } catch (DAOException ex) {
            logger.error(ex);
        }
    }

    public void grabarArchivosEntidad(List<ArchivoDto> listaArchivos, Long entidad, Long registro) throws FileNotFoundException, IOException {
        String separadorArchivoAbrir = "[";
        String separadorArchivoCerrar = "]";

        for (ArchivoDto a : listaArchivos) {
            a.setDetalle(a.getDetalle().toUpperCase());
            try {
                if (a.getId() == null) {
                    a.setEntidad(entidad);
                    a.setRegistro(registro);
                    StringBuffer sb = new StringBuffer("");
                    sb.append(separadorArchivoAbrir);
                    sb.append(entidad.toString());
                    sb.append(separadorArchivoCerrar);
                    sb.append("-");
                    sb.append(separadorArchivoAbrir);
                    sb.append(registro.toString());
                    sb.append(separadorArchivoCerrar);
                    sb.append("-");
                    sb.append(a.getNombre().toUpperCase());
                    a.setNombre(sb.toString());
                    File f = new File(applicationMBean.getArchivoConfiguracion() + sb.toString());
                    UtilCore.Archivo.copiarArchivoHD(f, a.getBites());
                    this.manager.nuevo(archivoDto);
                } else {
                    this.manager.editar(archivoDto);
                }
            } catch (DAOException e) {
                logger.error(e);
            }

        }

    }

    public void grabarArchivo(ArchivoDto a, Long entidad, Long registro) throws FileNotFoundException, IOException {
        String separadorArchivoAbrir = "[";
        String separadorArchivoCerrar = "]";

        if (a.getDetalle()!=null) {
            a.setDetalle(a.getDetalle().toUpperCase());
        } 
        
        a.setUsuarioDto(this.sessionMBean.getSessionUsuarioDto());
        a.setTerminal(this.sessionMBean.getSessionTerminal());
        a.setFecha(UtilCore.Fecha.obtenerFechaActualDate());
        
        try {
            if (a.getId() == null) {
                a.setUsuarioCreacionDto(this.sessionMBean.getSessionUsuarioDto());
                a.setTerminalCreacion(this.sessionMBean.getSessionTerminal());
                a.setFechaCreacion(UtilCore.Fecha.obtenerFechaActualDate());
                
                a.setEntidad(entidad);
                a.setRegistro(registro);
                
                StringBuilder sb = new StringBuilder("");
                sb.append(separadorArchivoAbrir);
                sb.append(entidad.toString());
                sb.append(separadorArchivoCerrar);
                sb.append("-");
                sb.append(separadorArchivoAbrir);
                sb.append(registro.toString());
                sb.append(separadorArchivoCerrar);
                sb.append("-");
                sb.append(a.getNombre().toUpperCase());
                a.setNombre(sb.toString());
                String ruta = applicationMBean.getRutaArchivos() + sb.toString();
                a.setRuta(ruta);
                

                File f = new File(ruta);
                
                UtilCore.Archivo.copiarArchivoHD(f, a.getBites());
                
                this.manager.nuevo(a);
                
                
            } else {                
                this.manager.editar(a);
            }
        } catch (DAOException e) {
            logger.error(e);
        }
    }
    
    public void listenerFile(FileUploadEvent event) {
        SessionMBean sessionMBean = (SessionMBean) WebServletContextListener.getApplicationContext().getBean("sessionMBean");
        Long entidad = sessionMBean.getEntidad();
        Long registro = sessionMBean.getRegistro();
        UploadedFile file = event.getFile();

        ArchivoDto archivoDto = new ArchivoDto();
        archivoDto.setEsAtributo(Boolean.FALSE);
        archivoDto.setNombre(file.getFileName());
        archivoDto.setTipoDto(null);
        archivoDto.setPeso(BigDecimal.valueOf(file.getSize()));
        archivoDto.setComentario("NUEVO ARCHIVO");
        archivoDto.setUsuarioDto(this.sessionMBean.getSessionUsuarioDto());
        archivoDto.setTerminal(this.sessionMBean.getSessionTerminal());
        archivoDto.setFecha(UtilCore.Fecha.obtenerFechaActualDate());
        archivoDto.setBites(file.getContents());
        archivoDto.setDetalle(archivoDto.getNombre());
        archivoDto.setEstado(Boolean.TRUE);
        if (archivoDto.getNombre().indexOf(".") != -1) {
            archivoDto.setExtension(archivoDto.getNombre().substring(archivoDto.getNombre().lastIndexOf(".") + 1, archivoDto.getNombre().length()));
        }
        try {
            grabarArchivo(archivoDto, entidad, registro);
        } catch (FileNotFoundException ex) {
            showError("ARCHIVO NO ENCONTRADO :: " + ex.getMessage());
            logger.error(ex);
        } catch (IOException ex) {
            showError("ERROR DE ENTRADA Y SALIDA :: " + ex.getMessage());
            logger.error(ex);
        }
        cargarArchivos(entidad, registro);
    }
    
    public void guardarArchivo(ArchivoDto a) {
        try {
            a.setFecha(UtilCore.Fecha.obtenerFechaActualDate());
            a.setTerminal(sessionMBean.getSessionTerminal());
            a.setUsuarioDto(sessionMBean.getSessionUsuarioDto());
            manager.editar(a);
            cargarArchivos(a.getEntidad(), a.getRegistro());
        } catch (DAOException ex) {
            logger.error(ex);
        }
    }
    
    public void eliminarArchivo() {
        try {
            manager.eliminar(archivoDto);
            cargarArchivos(archivoDto.getEntidad(), archivoDto.getRegistro());
        } catch (DAOException ex) {
            logger.error(ex);
        }
    }
    
    public void verArchivo() {
        manager.viewArchivoDownload(this.archivoDto.getNombre());
    }    
    

    public String grabarVarios() {


        String to = "";
        try {
            this.manager.guardarVarios(listaArchivos);
        } catch (DAOException ex) {
            logger.error(ex);
        }
        return to;
    }

    public List<ArchivoDto> getListaArchivos() {
        return listaArchivos;
    }

    public void setListaArchivos(List<ArchivoDto> listaArchivos) {
        this.listaArchivos = listaArchivos;
    }

    public static Logger getLogger() {
        return logger;
    }

    public static void setLogger(Logger logger) {
        ArchivoMBean.logger = logger;
    }

    public ArchivoManager getManager() {
        return manager;
    }

    public void setManager(ArchivoManager manager) {
        this.manager = manager;
    }

    public ArchivoDto getArchivoDto() {
        return archivoDto;
    }

    public void setArchivoDto(ArchivoDto archivoDto) {
        this.archivoDto = archivoDto;
    }

    public RecursosManager getRecursosManager() {
        return recursosManager;
    }

    public void setRecursosManager(RecursosManager recursosManager) {
        this.recursosManager = recursosManager;
    }

    public ApplicationMBean getApplicationMBean() {
        return applicationMBean;
    }

    public void setApplicationMBean(ApplicationMBean applicationMBean) {
        this.applicationMBean = applicationMBean;
    }

    public SessionMBean getSessionMBean() {
        return sessionMBean;
    }

    public void setSessionMBean(SessionMBean sessionMBean) {
        this.sessionMBean = sessionMBean;
    }

    public StreamedContent getFile() {
        return file;
    }

    public void setFile(StreamedContent file) {
        this.file = file;
    }
    
    
}
